//////////////////////////////////////////////////////////////////////////
#pragma once
#pragma managed
//////////////////////////////////////////////////////////////////////////
using namespace System;
using namespace System::Runtime::InteropServices;
//////////////////////////////////////////////////////////////////////////
NAMESPACE_BEGIN
//////////////////////////////////////////////////////////////////////////
public ref class ManagedEigenInput : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
	}

internal:
	ManagedEigenInput(CvInput* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvInput* ToCvInputPointer()
	{
		return (CvInput*)m_pHandle;
	}
};

public ref class ManagedImgObsInfo : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvImgObsInfo* pImgObsInfo = this->ToCvImgObsInfoPointer();
		cvReleaseObsInfo(&pImgObsInfo);
		this->m_pHandle = pImgObsInfo;
	}

internal:
	ManagedImgObsInfo(CvImgObsInfo* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvImgObsInfo* ToCvImgObsInfoPointer()
	{
		return (CvImgObsInfo*)m_pHandle;
	}
};

public ref class ManagedObsInfo1D : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
	}

internal:
	ManagedObsInfo1D(Cv1DObsInfo* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline Cv1DObsInfo* ToCvObsInfo1DPointer()
	{
		return (Cv1DObsInfo*)m_pHandle;
	}
};

public ref class ManagedEHMMState : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvEHMMState* pEHMMState = this->ToCvEHMMStatePointer();
		this->m_pHandle = pEHMMState;
	}

internal:
	ManagedEHMMState(CvEHMMState* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvEHMMState* ToCvEHMMStatePointer()
	{
		return (CvEHMMState*)m_pHandle;
	}
};

public ref class ManagedEHMM : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvEHMM* pEHMM = this->ToCvEHMMPointer();
		cvRelease2DHMM(&pEHMM);
		this->m_pHandle = pEHMM;
	}

internal:
	ManagedEHMM(CvEHMM* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvEHMM* ToCvEHMMPointer()
	{
		return (CvEHMM*)m_pHandle;
	}
};

public ref class ManagedGraphWeightedVtx : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvGraphWeightedVtx* pGraphWeightedVtx = this->ToCvGraphWeightedVtxPointer();
		this->m_pHandle = pGraphWeightedVtx;
	}

internal:
	ManagedGraphWeightedVtx(CvGraphWeightedVtx* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvGraphWeightedVtx* ToCvGraphWeightedVtxPointer()
	{
		return (CvGraphWeightedVtx*)m_pHandle;
	}
};


public ref class ManagedGraphWeightedEdge : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvGraphWeightedEdge* pGraphWeightedEdge = this->ToCvGraphWeightedEdgePointer();
		this->m_pHandle = pGraphWeightedEdge;
	}

internal:
	ManagedGraphWeightedEdge(CvGraphWeightedEdge* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvGraphWeightedEdge* ToCvGraphWeightedEdgePointer()
	{
		return (CvGraphWeightedEdge*)m_pHandle;
	}
};

public ref class ManagedCliqueFinder : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvCliqueFinder* pCliqueFinder = this->ToCvCliqueFinderPointer();
		this->m_pHandle = pCliqueFinder;
	}

internal:
	ManagedCliqueFinder(CvCliqueFinder* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvCliqueFinder* ToCvCliqueFinderPointer()
	{
		return (CvCliqueFinder*)m_pHandle;
	}
};

public ref class ManagedStereoCamera : NativeHandleObject
{
public:
	ManagedStereoCamera() : NativeHandleObject(new CvStereoCamera(), true)
	{
	}

protected:
	virtual void ReleaseHandle() override
	{
		delete this->m_pHandle;
	}

internal:
	inline CvStereoCamera* ToCvStereoCameraPointer()
	{
		return (CvStereoCamera*)m_pHandle;
	}
};

public ref class ManagedGLCM : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvGLCM* pGLCM = this->ToCvGLCMPointer();
		cvReleaseGLCM(&pGLCM);
		this->m_pHandle = pGLCM;
	}

internal:
	ManagedGLCM(CvGLCM* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvGLCM* ToCvGLCMPointer()
	{
		return (CvGLCM*)m_pHandle;
	}
};

public ref class ManagedFaceTracker : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvFaceTracker* pFaceTracker = this->ToCvFaceTrackerPointer();
		cvReleaseFaceTracker(&pFaceTracker);
		this->m_pHandle = pFaceTracker;
	}

internal:
	ManagedFaceTracker(CvFaceTracker* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvFaceTracker* ToCvFaceTrackerPointer()
	{
		return (CvFaceTracker*)m_pHandle;
	}
};

public ref class ManagedVoronoiSite2D : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvVoronoiSite2D* pVoronoiSite2D = this->ToCvVoronoiSite2DPointer();
		this->m_pHandle = pVoronoiSite2D;
	}

internal:
	ManagedVoronoiSite2D(CvVoronoiSite2D* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvVoronoiSite2D* ToCvVoronoiSite2DPointer()
	{
		return (CvVoronoiSite2D*)m_pHandle;
	}
};


public ref class ManagedVoronoiEdge2D : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvVoronoiEdge2D* pVoronoiEdge2D = this->ToCvVoronoiEdge2DPointer();
		this->m_pHandle = pVoronoiEdge2D;
	}

internal:
	ManagedVoronoiEdge2D(CvVoronoiEdge2D* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvVoronoiEdge2D* ToCvVoronoiEdge2DPointer()
	{
		return (CvVoronoiEdge2D*)m_pHandle;
	}
};

public ref class ManagedVoronoiNode2D : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvVoronoiNode2D* pVoronoiNode2D = this->ToCvVoronoiNode2DPointer();
		this->m_pHandle = pVoronoiNode2D;
	}

internal:
	ManagedVoronoiNode2D(CvVoronoiNode2D* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvVoronoiNode2D* ToCvVoronoiNode2DPointer()
	{
		return (CvVoronoiNode2D*)m_pHandle;
	}
};

public ref class ManagedVoronoiDiagram2D : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvVoronoiDiagram2D* pVoronoiDiagram2D = this->ToCvVoronoiDiagram2DPointer();
		this->m_pHandle = pVoronoiDiagram2D;
	}

internal:
	ManagedVoronoiDiagram2D(CvVoronoiDiagram2D* handle) : NativeHandleObject(handle, false)
	{
	}

	inline CvVoronoiDiagram2D* ToCvVoronoiDiagram2DPointer()
	{
		return (CvVoronoiDiagram2D*)m_pHandle;
	}
};

public ref class ManagedLCMEdge : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvLCMEdge* pLCMEdge = this->ToCvLCMEdgePointer();
		this->m_pHandle = pLCMEdge;
	}

internal:
	ManagedLCMEdge(CvLCMEdge* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvLCMEdge* ToCvLCMEdgePointer()
	{
		return (CvLCMEdge*)m_pHandle;
	}
};

public ref class ManagedLCMNode : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvLCMNode* pLCMNode = this->ToCvLCMNodePointer();
		this->m_pHandle = pLCMNode;
	}

internal:
	ManagedLCMNode(CvLCMNode* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvLCMNode* ToCvLCMNodePointer()
	{
		return (CvLCMNode*)m_pHandle;
	}
};

public ref class ManagedBGStatModel : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvBGStatModel* pBGStatModel = this->ToCvBGStatModelPointer();
		this->m_pHandle = pBGStatModel;
	}

internal:
	ManagedBGStatModel(CvBGStatModel* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvBGStatModel* ToCvBGStatModelPointer()
	{
		return (CvBGStatModel*)m_pHandle;
	}
};

public ref class ManagedBGPixelStat : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvBGPixelStat* pBGPixelStat = this->ToCvBGPixelStatPointer();
		this->m_pHandle = pBGPixelStat;
	}

internal:
	ManagedBGPixelStat(CvBGPixelStat* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvBGPixelStat* ToCvBGPixelStatPointer()
	{
		return (CvBGPixelStat*)m_pHandle;
	}
};

public ref class ManagedFGDStatModel : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvFGDStatModel* pFGDStatModel = this->ToCvFGDStatModelPointer();
		this->m_pHandle = pFGDStatModel;
	}

internal:
	ManagedFGDStatModel(CvFGDStatModel* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvFGDStatModel* ToCvFGDStatModelPointer()
	{
		return (CvFGDStatModel*)m_pHandle;
	}
};

public ref class ManagedGaussBGPoint : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvGaussBGPoint* pGaussBGPoint = this->ToCvGaussBGPointPointer();
		this->m_pHandle = pGaussBGPoint;
	}

internal:
	ManagedGaussBGPoint(CvGaussBGPoint* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvGaussBGPoint* ToCvGaussBGPointPointer()
	{
		return (CvGaussBGPoint*)m_pHandle;
	}
};

public ref class ManagedGaussBGModel : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvGaussBGModel* pGaussBGModel = this->ToCvGaussBGModelPointer();
		this->m_pHandle = pGaussBGModel;
	}

internal:
	ManagedGaussBGModel(CvGaussBGModel* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvGaussBGModel* ToCvGaussBGModelPointer()
	{
		return (CvGaussBGModel*)m_pHandle;
	}
};

public ref class ManagedBGCodeBookElem : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvBGCodeBookElem* pBGCodeBookElem = this->ToCvBGCodeBookElemPointer();
		this->m_pHandle = pBGCodeBookElem;
	}

internal:
	ManagedBGCodeBookElem(CvBGCodeBookElem* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvBGCodeBookElem* ToCvBGCodeBookElemPointer()
	{
		return (CvBGCodeBookElem*)m_pHandle;
	}
};

public ref class ManagedBGCodeBookModel : NativeHandleObject
{
protected:
	virtual void ReleaseHandle() override
	{
		CvBGCodeBookModel* pBGCodeBookModel = this->ToCvBGCodeBookModelPointer();
		cvReleaseBGCodeBookModel(&pBGCodeBookModel);
		this->m_pHandle = pBGCodeBookModel;
	}

internal:
	ManagedBGCodeBookModel(CvBGCodeBookModel* handle, bool own) : NativeHandleObject(handle, own)
	{
	}

	inline CvBGCodeBookModel* ToCvBGCodeBookModelPointer()
	{
		return (CvBGCodeBookModel*)m_pHandle;
	}
};
//////////////////////////////////////////////////////////////////////////
NAMESPACE_END
//////////////////////////////////////////////////////////////////////////